home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / ggraph / commands.c < prev    next >
C/C++ Source or Header  |  1990-04-08  |  18KB  |  702 lines
  1. #include <stdio.h>
  2. #include <errno.h>
  3. #include <strings.h>
  4. #include <math.h>
  5. #include <ctype.h>
  6. #include "ggraph.h"
  7. #include "commands.h"
  8. #include "ggraphdefs.h"
  9.  
  10. int interact;            /* switch for interactive mode */
  11. /****************************************************************
  12.  *                                *
  13.  *    readcmds - read the graph commands in             *
  14.  *                                *
  15.  ****************************************************************/
  16. readcmds (infile)
  17. FILE *infile;
  18. {
  19.  
  20.     ++curgraph;            /* a new graph */
  21.     cg.gtitle.t_xpos = 0.0;
  22.     cg.gtitle.t_ypos = 0.0;
  23.     cg.gtype = -1;
  24.     cg.gframe.fsize = -1;
  25.     cg.gtitle.t_size = -1;
  26.     cg.legend.t_size = -1;
  27.     cg.yvert = -1;
  28.     cg.xtick.t_size = -1;
  29.     cg.ytick.t_size = -1;
  30.     cg.xlabel.t_size = -1;
  31.     cg.ylabel.t_size = -1;
  32.     cg.gtitle.t_font = -1;
  33.     cg.legend.t_font = -1;
  34.     cg.xlabel.t_font = -1;
  35.     cg.ylabel.t_font = -1;
  36.     cg.xtick.t_font = -1;
  37.     cg.ytick.t_font = -1;
  38.     cg.xgrid_type = -1;
  39.     cg.ygrid_type = -1;
  40.     cg.xpreci1 = -1;
  41.     cg.ypreci1 = -1;
  42.     cg.xpreci2 = -1;
  43.     cg.ypreci2 = -1;
  44.     cg.symbolsz = -1;
  45.     cg.logxsw = -1;
  46.     cg.logysw = -1;
  47.     cg.gminx = HUGE;
  48.     cg.gminy = HUGE;
  49.     cg.gmaxx = -HUGE;
  50.     cg.gmaxy = -HUGE;
  51.     curline = -1;
  52.     rreadcmds(infile);
  53.     return;
  54. }
  55.  
  56. /****************************************************************
  57.  *                                *
  58.  *    rreadcmds - recursivly read the graph commands in    *
  59.  *                                *
  60.  ****************************************************************/
  61. rreadcmds (readfile)
  62. FILE *readfile;
  63. {
  64.     char    cmd[4];
  65.     char    cargs[80];
  66.     register int    line1;
  67.     register int    ncmd;
  68.     register int i;
  69.     int     ilarg, ilarg1;
  70.     char    larg[40];
  71.     char    linename[20];
  72.     register char   c;
  73.     FILE *infile;
  74.     FILE *oinfile;        /* place to hole file pointer */
  75.  
  76.     infile = readfile;
  77.     while (TRUE) {
  78.     if((interact) && (infile == stdin))
  79.       printf("(gg)");
  80.     while (isspace(c = getc (infile)));/* strip blanks */
  81.     ungetc (c, infile);
  82.     if (NULL == fgets (cmd, 4, infile))/* read a command */
  83.         return;
  84.     while (isspace(c = getc (infile)));/* strip blanks */
  85.     ungetc (c, infile);
  86.     fgets (cargs, 81, infile);/* read command arguments */
  87.     if (strlen (cargs) > 1)
  88.         cargs[strlen (cargs) - 1] = NULL;
  89.     for(i=0;((i != 79) && (cargs[i] != COMMENTCHAR) && 
  90.          (cargs[i] != NULL));++i);
  91.     cargs[i] = NULL;
  92.     strip(cargs);
  93.     if ((ncmd = findcmd (cmd)) == ERROR) {/* what command was it */
  94.         printf ("unrecognized command |%s|\n", cmd);
  95.         ncmd = MAXCOMMAND+1;
  96.     }
  97.     switch (ncmd) {
  98.         case XGRID: 
  99.             xgridf = onoff(cargs);
  100.         break;
  101.         case YGRID: 
  102.             ygridf = onoff(cargs);
  103.         break;
  104.         case XAXIS: 
  105.         xaxisf = onoff(cargs);
  106.         break;
  107.         case YAXIS: 
  108.         yaxisf = onoff(cargs);
  109.         break;
  110.         case XTICK: 
  111.         xtickf = onoff(cargs);
  112.         break;
  113.         case YTICK: 
  114.         ytickf = onoff(cargs);
  115.         break;
  116.         case XTICKL: 
  117.         xticklf = onoff(cargs);
  118.         break;
  119.         case YTICKL: 
  120.         yticklf = onoff(cargs);
  121.         break;
  122.         case TITFLG: 
  123.         titlef = onoff(cargs);
  124.         break;
  125.         case TITLE: 
  126.         strcpy (cg.gtitle.t_text, cargs);
  127.         break;
  128.         case XLABLE: 
  129.         strcpy (cg.xlabel.t_text, cargs);
  130.         break;
  131.         case YLABLE: 
  132.         strcpy (cg.ylabel.t_text, cargs);
  133.         break;
  134.         case DATASTART: 
  135.         if(debug)fprintf (stderr, "reading data |%s|\n", cargs);
  136.         cg.logxtick = -1;
  137.         cg.logytick = -1;
  138.         cg.dtickx = 0.0;
  139.         cg.dticky = 0.0;
  140.         cg.maxlines = readpoints (infile,cargs);/* read the points in */
  141.         if(debug)fprintf (stderr, "Done reading %s\n", cargs);
  142.         break;
  143.         case DRAW: 
  144.         if (outfile == NULL) {
  145.         /* is there any place to put this */
  146.             if (strlen (cargs) > 1) {
  147.             /* open output file */
  148.             for(i=0;((i != 79) && (cargs[i] != COMMENTCHAR) &&
  149.               (cargs[i] != BLANK) && (cargs[i] != NULL));++i);
  150.             cargs[i] = NULL;
  151.             if ((outfile = fopen (cargs, "w")) == NULL) {
  152.                 perror ("can't open output file using stdout");
  153.                 outfile = stdout;
  154.             }
  155.             setbuf (outfile, NULL);/* no buffering */
  156.             }
  157.             else {
  158.             outfile = stdout;
  159.             setbuf (outfile, NULL);/* no buffering */
  160.             }
  161.         }
  162.         else {
  163.             if (strlen (cargs) > 1) {
  164.             fclose (outfile);
  165.             /* open output file */
  166.             i=0;
  167.             while((i != 79) && (cargs[i] != COMMENTCHAR) &&
  168.               (cargs[i] != BLANK) && (cargs[i] != NULL))++i;
  169.             cargs[i] = NULL;
  170.             if ((outfile = fopen (cargs, "w")) == NULL) {
  171.                 perror ("can't open output file using stdout");
  172.                 exit (0);
  173.             }
  174.             else
  175.                 setbuf (outfile, NULL);/* no buffering */
  176.             }
  177.         }
  178.         /* draw graph */
  179.         if(debug) fprintf (stderr, "Drawing graph %s\n", cargs);
  180.         strcpy(graphname, cargs);
  181.         setdefault ();    /* set defaults for graph */
  182.         setlim ();    /* set the limits for the graph */
  183.         gremlinheader ();/* set up header for file */
  184.         switch (cg.gtype) {/* draw the graph */
  185.             case LINEAR: 
  186.             plotpoints ();
  187.             break;
  188.             case HIST: 
  189.             hist ();
  190.             break;
  191.             case LOG: 
  192.             case PIE: 
  193.             case BAR: 
  194.             default: 
  195.             fprintf (stderr, "Graph type unsupported %d\n",
  196.                 cg.gtype);
  197.             break;
  198.         }
  199.         /* draw and label axis */
  200.         if (!cg.axline_type)
  201.             cg.axline_type = BRUSH_THICK;
  202.         drawaxis ();
  203.         if (framef)
  204.             drawframe ();
  205.         if (titlef && (strlen(cg.gtitle.t_text) > 0))    /* draw the title */
  206.             drawctext (cg.gtitle.t_xpos, cg.gtitle.t_ypos,
  207.                 cg.gtitle.t_font, cg.gtitle.t_size, 
  208.                 cg.gtitle.t_text, TOPCENTER_TEXT);
  209.         if(legendf)
  210.           drawlegend();
  211.         fprintf (outfile, "%4.1f\n", LASTPOINT);/* close file */
  212.         fclose(outfile);
  213.         if(debug)fprintf (stderr, "Graph done\n");
  214.         cg.xorigin = 0.0;
  215.         cg.yorigin = 0.0;
  216.         break;
  217.         case SETX: 
  218.         cg.maxtickx = 0;
  219.         cg.mintickx = 0;
  220.         cg.stickx = 0;
  221.         cg.numtickx = 0;
  222.         if(cg.logxsw == TRUE)
  223.           sscanf (cargs, "%d %f %f %f ", &cg.numtickx, &cg.logxtick,
  224.           &cg.stickx, &cg.xorigin);
  225.         else
  226.           sscanf (cargs, "%d %f %f %f ", &cg.numtickx, &cg.dtickx,
  227.             &cg.stickx, &cg.xorigin);
  228.         break;
  229.         case SETY: 
  230.         cg.maxticky = 0;
  231.         cg.minticky = 0;
  232.         cg.sticky = 0;
  233.         cg.numticky = 0;
  234.         if(cg.logysw == TRUE)
  235.           sscanf (cargs, "%d %f %f %f ", &cg.numticky, &cg.logytick,
  236.           &cg.sticky, &cg.yorigin);
  237.         else
  238.           sscanf (cargs, "%d %f %f %f ", &cg.numticky, &cg.dticky,
  239.             &cg.sticky, &cg.yorigin);
  240.         break;
  241.         case LTYPE: 
  242. /*         linearg(cargs, foobar); */
  243.         sscanf (cargs, "%s %d", linename, &ilarg);
  244.         if((line1 = findline (linename)) != ERROR)
  245.           if(line1 == ALLINES){
  246.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  247.               cg.lines[i]->ltype = ilarg;
  248.           }else
  249.             cg.lines[line1]->ltype = ilarg;
  250.         else
  251.           fprintf(stderr,"Illegal line name %s\n", linename);
  252.         break;
  253.         case LCURVE: 
  254.         sscanf (cargs, "%s %d", linename, &ilarg);
  255.         if((line1 = findline (linename)) != ERROR)
  256.           if(line1 == ALLINES){
  257.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  258.               cg.lines[i]->ctype = ilarg;
  259.           }else
  260.           cg.lines[line1]->ctype = ilarg;
  261.         else
  262.           fprintf(stderr,"Illegal line name %s\n", linename);
  263.         break;
  264.         case LONOFF: 
  265.         sscanf (cargs, "%s %s", linename, larg);
  266.         if((line1 = findline (linename)) != ERROR){
  267.           if(line1 == ALLINES){
  268.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i){
  269.             if (strncmp ("off", larg, 4) == 0)
  270.               cg.lines[i]->lonoff = 0;
  271.             if (strncmp ("on", larg, 4) == 0)
  272.               cg.lines[i]->lonoff = 1;
  273.             }
  274.           }else{
  275.             if (strncmp ("off", larg, 4) == 0)
  276.               cg.lines[line1]->lonoff = 0;
  277.             if (strncmp ("on", larg, 4) == 0)
  278.               cg.lines[line1]->lonoff = 1;
  279.           }
  280.         }
  281.         else
  282.           fprintf(stderr,"Illegal line name %s\n", linename);
  283.         break;
  284.         case LSYM: 
  285.         sscanf (cargs, "%s %d", linename, &ilarg);
  286.         if((line1 = findline (linename)) != ERROR)
  287.           if(line1 == ALLINES){
  288.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  289.               cg.lines[i]->mtype = ilarg;
  290.           }else
  291.               cg.lines[line1]->mtype = ilarg;
  292.         else
  293.           fprintf(stderr,"Illegal line name %s\n", linename);
  294.         break;
  295.         case LINELABEL: 
  296.         sscanf (cargs, "%s %s", linename, larg);
  297.         if((line1 = findline (linename)) != ERROR){
  298.           if(line1 == ALLINES){
  299.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i){
  300.             if (strncmp ("off", larg, 4) == 0)
  301.               cg.lines[i]->llabsw = 0;
  302.             if (strncmp ("on", larg, 4) == 0)
  303.               cg.lines[i]->llabsw = 1;
  304.             }
  305.           }else{
  306.             if (strncmp ("off", larg, 4) == 0)
  307.               cg.lines[line1]->llabsw = 0;
  308.             if (strncmp ("on", larg, 4) == 0)
  309.               cg.lines[line1]->llabsw = 1;
  310.           }
  311.         }
  312.         else
  313.           fprintf(stderr,"Illegal line name %s\n", linename);
  314.         break;
  315.         case LLINELABPOS: 
  316.         sscanf (cargs, "%s %f %f", linename, &graphx, &graphy);
  317.         if((line1 = findline (linename)) != ERROR){
  318.             cg.lines[line1]->llabel.t_xpos = graphx;
  319.             cg.lines[line1]->llabel.t_ypos = graphy;
  320.         }
  321.         else
  322.           fprintf(stderr,"Illegal line name %s\n", linename);
  323.         break;
  324.         case SLINELABEL: 
  325.         sscanf (cargs, "%s ", linename);
  326.         if((line1 = findline (linename)) != ERROR)
  327.           strcpy (cg.lines[line1]->llabel.t_text,
  328.              &cargs[strlen (linename) + 1]);
  329.         else
  330.           fprintf(stderr,"Illegal line name %s\n", linename);
  331.         break;
  332.         case FRAME: 
  333.         framef = onoff(cargs);
  334.         break;
  335.         case FRAMETHICK: 
  336.         sscanf (cargs, "%d", &ilarg);
  337.         cg.gframe.fsize = ilarg;
  338.         break;
  339.         case XGRTYPE: 
  340.         sscanf (cargs, "%d", &ilarg);
  341.         cg.xgrid_type = ilarg;
  342.         break;
  343.         case YGRTYPE: 
  344.         sscanf (cargs, "%d", &ilarg);
  345.         cg.ygrid_type = ilarg;
  346.         break;
  347.         case TITLEPOS: 
  348.         sscanf (cargs, "%d %d", &ilarg, &ilarg1);
  349.         cg.gtitle.t_xpos = ilarg;
  350.         cg.gtitle.t_ypos = ilarg1;
  351.         break;
  352.         case XPOS: 
  353.         sscanf (cargs, "%d %d", &ilarg, &ilarg1);
  354.         cg.xlabel.t_xpos = ilarg;
  355.         cg.xlabel.t_ypos = ilarg1;
  356.         break;
  357.         case YPOS: 
  358.         sscanf (cargs, "%d %d", &ilarg, &ilarg1);
  359.         cg.ylabel.t_xpos = ilarg;
  360.         cg.ylabel.t_ypos = ilarg1;
  361.         break;
  362.         case TITLESIZE: 
  363.         sscanf (cargs, "%d", &ilarg);
  364.         cg.gtitle.t_size = ilarg;
  365.         break;
  366.         case YSIZE: 
  367.         sscanf (cargs, "%d", &ilarg);
  368.         cg.ylabel.t_size = ilarg;
  369.         break;
  370.         case XSIZE: 
  371.         sscanf (cargs, "%d", &ilarg);
  372.         cg.xlabel.t_size = ilarg;
  373.         break;
  374.         case LTHICK: 
  375.         sscanf (cargs, "%s %d", linename, &ilarg);
  376.         if((line1 = findline (linename)) != ERROR)
  377.           if(line1 == ALLINES){
  378.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  379.               cg.lines[i]->lsize = ilarg;
  380.           }else
  381.             cg.lines[line1]->lsize = ilarg;
  382.         else
  383.           fprintf(stderr,"Illegal line name %s\n", linename);
  384.         break;
  385.         case GTYPE: 
  386.         sscanf (cargs, "%d", &ilarg);
  387.         cg.gtype = ilarg;
  388.         break;
  389.         case XPRECISION:
  390.         sscanf (cargs, "%d %d", &ilarg, &ilarg1);
  391.         cg.xpreci1 = ilarg + ilarg1;
  392.         cg.xpreci2 = ilarg1;
  393.         break;
  394.         case YPRECISION:
  395.         sscanf (cargs, "%d %d", &ilarg, &ilarg1);
  396.         cg.ypreci1 = ilarg + ilarg1;
  397.         cg.ypreci2 = ilarg1;
  398.         break;
  399.         case SYMBOLSZ: 
  400.         sscanf (cargs, "%d", &ilarg);
  401.         cg.symbolsz = (float)ilarg;
  402.         break;
  403.         case SYMBOLSW: 
  404.         symbsw = onoff(cargs);
  405.         break;
  406.         case TITLEFT: 
  407.         sscanf (cargs, "%d", &ilarg);
  408.         cg.gtitle.t_font = ilarg;
  409.         break;
  410.         case XFONT: 
  411.         sscanf (cargs, "%d", &ilarg);
  412.         cg.xlabel.t_font = ilarg;
  413.         break;
  414.         case YFONT: 
  415.         sscanf (cargs, "%d", &ilarg);
  416.         cg.ylabel.t_font = ilarg;
  417.         break;
  418.         case READ:
  419.         oinfile = infile;
  420.         if((!strlen(cargs) > 1)){
  421.           fprintf(stderr, "No file name in read command\n");
  422.           break;
  423.         }
  424.         for(i=0;((i != 79) && (cargs[i] != COMMENTCHAR) &&
  425.           (cargs[i] != BLANK) && (cargs[i] != NULL));++i);
  426.         cargs[i] = NULL;
  427.         if ((infile = fopen (cargs, "r")) == NULL) {/* open input file */
  428.             perror ("can't open input file");
  429.             exit (-1);
  430.         }
  431.         rreadcmds(infile);
  432.         fclose(infile);
  433.         infile = oinfile;
  434.         break;
  435.         case VERTICALT: 
  436.         cg.yvert = onoff(cargs);
  437.         break;
  438.         case LOGX: 
  439.         cg.dtickx = 0.0;
  440.         cg.maxtickx = 0;
  441.         cg.numtickx = 0;
  442.         cg.logxsw = onoff(cargs);
  443.         break;
  444.         case LOGY: 
  445.         cg.dticky = 0.0;
  446.         cg.maxticky = 0;
  447.         cg.numticky = 0;
  448.         cg.logysw = onoff(cargs);
  449.         break;
  450.         case LOGLOG: 
  451.         cg.dtickx = 0.0;
  452.         cg.dticky = 0.0;
  453.         cg.maxtickx = 0;
  454.         cg.maxticky = 0;
  455.         cg.numtickx = 0;
  456.         cg.numticky = 0;
  457.         if (strncmp ("off", cargs, 4) == 0){
  458.             cg.logxsw = FALSE;
  459.             cg.logysw = FALSE;
  460.         }
  461.         if (strncmp ("on", cargs, 4) == 0){
  462.             cg.logxsw = TRUE;
  463.             cg.logysw = TRUE;
  464.         }
  465.         break;
  466.         case QUIT:
  467.         return;
  468.         break;
  469.         case FIRST_LAB:
  470.         if (strncmp ("off", cargs, 4) == 0){
  471.             cg.firstxsw = 1;
  472.             cg.firstysw = 1;
  473.         }
  474.         if (strncmp ("on", cargs, 4) == 0){
  475.             cg.firstysw = 0;
  476.             cg.firstxsw = 0;
  477.         }
  478.         break;
  479.         case FIRST_LAB_X:
  480.         cg.firstxsw = onoff(cargs);
  481.         break;
  482.         case FIRST_LAB_Y:
  483.         cg.firstysw = onoff(cargs);
  484.         break;
  485.         case COMMENT:    /* comment line do nothing */
  486.         break;
  487.         case AXCROSS:
  488.         if (strncmp ("off", cargs, 4) == 0){
  489.             crossysw = FALSE;
  490.             crossxsw = FALSE;
  491.         }
  492.         if (strncmp ("on", cargs, 4) == 0){
  493.             crossxsw = TRUE;
  494.             crossysw = TRUE;
  495.         }
  496.         break;
  497.         case AXCROSS_X:
  498.         crossxsw = onoff(cargs);
  499.         break;
  500.         case AXCROSS_Y:
  501.         crossysw = onoff(cargs);
  502.         break;
  503.         case LEGEND:
  504.         cg.xlabel.t_xpos = 0.0;
  505.         cg.xlabel.t_ypos = 0.0;
  506.         legendf = onoff(cargs);
  507.         break;
  508.         case LEGEND_SIDE:
  509.         cg.xlabel.t_xpos = 0.0;
  510.         cg.xlabel.t_ypos = 0.0;
  511.         legendside = onoff(cargs);
  512.         break;
  513.         case LEGEND_BOX:
  514.         legendbox = onoff(cargs);
  515.         break;
  516.         case SET_LEGEND_LABEL: 
  517.         sscanf (cargs, "%s ", linename);
  518.         if((line1 = findline (linename)) != ERROR)
  519.           strcpy (cg.lines[line1]->llelabel.t_text,
  520.              &cargs[strlen (linename) + 1]);
  521.         else
  522.           fprintf(stderr,"Illegal line name %s\n", linename);
  523.         break;
  524.         case SET_LEGEND_HEADING: 
  525.         strcpy (cg.legend.t_text, cargs);
  526.         break;
  527.         case SET_LEGEND_HEAD_FONT: 
  528.         sscanf (cargs, "%d", &ilarg);
  529.         cg.legend.t_font = ilarg;
  530.         break;
  531.         case SET_LEGEND_HEAD_SIZE: 
  532.         sscanf (cargs, "%d", &ilarg);
  533.         cg.legend.t_size = ilarg;
  534.         break;
  535.         case XTICK_FONT:
  536.         sscanf (cargs, "%d", &ilarg);
  537.         cg.xtick.t_font = ilarg;
  538.         break;
  539.         case YTICK_FONT:
  540.         sscanf (cargs, "%d", &ilarg);
  541.         cg.ytick.t_font = ilarg;
  542.         break;
  543.         case XTICK_SIZE:
  544.         sscanf (cargs, "%d", &ilarg);
  545.         cg.xtick.t_size = ilarg;
  546.         break;
  547.         case YTICK_SIZE:
  548.         sscanf (cargs, "%d", &ilarg);
  549.         cg.ytick.t_size = ilarg;
  550.         break;
  551.         case XSET: 
  552.         cg.maxtickx = 0;
  553.         cg.mintickx = 0;
  554.         cg.stickx = 0;
  555.         cg.numtickx = 0;
  556.         if(cg.logxsw == TRUE)
  557.           sscanf (cargs, "%f %f %f %d", &cg.logxtick, &cg.gminx,
  558.           &cg.gmaxx, &cg.numtickx);
  559.         else{
  560.           sscanf (cargs, "%f %f %d", &cg.gminx, &cg.gmaxx, &cg.numtickx);
  561.           if(cg.numtickx)
  562.             cg.dtickx = (cg.gmaxx - cg.gminx)/cg.numtickx;
  563.           cg.stickx = cg.gminx;
  564.         }
  565.         break;
  566.         case YSET: 
  567.         cg.maxticky = 0;
  568.         cg.minticky = 0;
  569.         cg.sticky = 0;
  570.         cg.numticky = 0;
  571.         if(cg.logysw == TRUE)
  572.           sscanf (cargs, "%f %f %f %d", &cg.logytick, &cg.gminy,
  573.           &cg.gmaxy, &cg.numticky);
  574.         else{
  575.           sscanf (cargs, "%f %f %d", &cg.gminy, &cg.gmaxy, &cg.numticky);
  576.           if(cg.numticky)
  577.             cg.dticky = (cg.gmaxy - cg.gminy)/cg.numticky;
  578.           cg.sticky = cg.gminy;
  579.         }
  580.         break;
  581.         case LINE_LAB_FONT:
  582.         sscanf (cargs, "%s %d", linename, &ilarg);
  583.         if((line1 = findline (linename)) != ERROR)
  584.           if(line1 == ALLINES){
  585.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  586.               cg.lines[i]->llabel.t_font = ilarg;
  587.           }else
  588.             cg.lines[line1]->llabel.t_font = ilarg;
  589.         else
  590.           fprintf(stderr,"Illegal line name %s\n", linename);
  591.         break;
  592.         case LINE_LAB_SIZE:
  593.         sscanf (cargs, "%s %d", linename, &ilarg);
  594.         if((line1 = findline (linename)) != ERROR)
  595.           if(line1 == ALLINES){
  596.             for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  597.               cg.lines[i]->llabel.t_size = ilarg;
  598.           }else
  599.             cg.lines[line1]->llabel.t_size = ilarg;
  600.         else
  601.           fprintf(stderr,"Illegal line name %s\n", linename);
  602.         break;
  603.         case SET_UNITS:
  604.         sscanf (cargs, "%d", cg.graph_units);
  605.         break;
  606.         case XAXIS_LENGTH:
  607.         sscanf (cargs, "%d", cg.xaxis_length);
  608.         break;
  609.         case YAXIS_LENGTH:
  610.         sscanf (cargs, "%d", cg.yaxis_length);
  611.         break;
  612.         default: 
  613.         fprintf(stderr, "Command found but not found\n");
  614.         break;
  615.     }
  616.     }
  617. }
  618.  
  619. findcmd (cmdstr)
  620. char   *cmdstr;
  621. {
  622.     register int    i;
  623.  
  624.     if (strlen (cmdstr) == 1) 
  625.       return(MAXCOMMAND+1);
  626.     for (i = 0; i != MAXCOMMAND; ++i) {
  627.     if (strncmp (commands[i], cmdstr, 3) == 0)
  628.         return (i);
  629.     }
  630.     return (ERROR);
  631. }
  632.  
  633. findline (line_name)
  634. char   *line_name;
  635. {
  636.     register int    i;
  637.     if(strncmp("all", line_name, 20) == 0) /* special case all */
  638.       return(ALLINES);
  639.     for (i = 0; ((i != MAXLINES) && (cg.lines[i] != NULL)); ++i) {
  640.     if (strncmp (cg.lines[i]->lname, line_name, 20) == 0)
  641.         return (i);
  642.     }
  643.     return (ERROR);
  644. }
  645.  
  646. /* strip blanks from front and back of line */
  647. strip(strip_line)
  648. char strip_line[];
  649. {
  650.     register int i;        /* a counter */
  651.     char temp_line[80];        /* place to hold line while we work on it */
  652.  
  653.     for(i=0;i!=80;++i)
  654.       temp_line[i] = strip_line[i];
  655.     i = 0;            /* reset pointer */
  656.     while(isspace(temp_line[i]))/* strip leading blanks */
  657.       ++i;
  658.     for(;((i!=80) && (strip_line[i] != NULL));++i)/* move back */
  659.       strip_line[i] = temp_line[i];
  660.     --i;
  661.     while(isspace(strip_line[i]))/* strip leading blanks */
  662.       --i;
  663.     ++i;
  664.     strip_line[i] = NULL;
  665. }
  666.  
  667. onoff(command_arg)
  668. char *command_arg;
  669. {   
  670.     
  671.     if (strncmp ("off", command_arg, 4) == 0)
  672.     return(FALSE);
  673.     if (strncmp ("on", command_arg, 4) == 0)
  674.     return(TRUE);
  675.     else
  676.     return(ERROR);
  677. }
  678.  
  679. linearg(command_arg, line_field)
  680. char *command_arg;
  681. int line_field;
  682. {   
  683. char linename[20];
  684. register int line1, i;
  685. int ilarg;        
  686.  
  687.     sscanf (command_arg, "%s %d", linename, &ilarg);
  688.     if((line1 = findline (linename)) != ERROR)
  689.     if(line1 == ALLINES){
  690.         for(i=0;((i!=MAXLINES) && (cg.lines[i] != NULL));++i)
  691.         cg.lines[i]->ltype = ilarg;
  692.     }else
  693.             cg.lines[line1]->ltype = ilarg;
  694.     else
  695.     fprintf(stderr,"Illegal line name %s\n", linename);
  696.     return;
  697. }
  698.  
  699. globalarg()
  700. {   
  701. }
  702.